Implement multi-parent packed scan for CSR rel tables - #867

Implement docs/multi_parent_lifetime.md's "for now" recommendation:

- Keep the owned std::vector<sel_t> parentPositions copy in
  PackedChildSlices; explicitly document why a pointer/alias into the
  parent's SelectionVector is unsafe (contents rewritten in place by
  setToFiltered/setToUnfiltered).
- Document the synchronous-consumption lifetime rule: the descriptor is
  valid only for the current output batch and must not be persisted
  across a materialization boundary.
- Record the deferred multi-parent convention (shared_ptr sel vector +
  prefix-sum offsets over all parents, zeros allowed) for when the
  multi-parent packed scan is implemented.
- Add a unit test codifying the owned-copy invariant against in-place
  sel vector mutation.

Implement the deferred design from docs/multi_parent_lifetime.md:

Representation (PackedChildSlices):
- Replace the owned parentPositions copy with a shared_ptr alias to the
  bound (parent) chunk state's selection vector plus a prefix-sum
  offsets vector over ALL served parents (offsets.size() ==
  parentSelSize + 1). Zero-length ranges (parents without children in
  the batch) are allowed; consumers skip them. The shared_ptr keeps the
  SelectionVector object alive while still aliasing mutable contents,
  preserving the synchronous-consumption lifetime rule.

Storage (CSRNodeGroup):
- Add tryScanCachedTuplesPacked: serves children of as many consecutive
  parents as fit into one output batch from the row cache, building the
  combined (filtered) output selection vector, the per-parent prefix
  sum in RelTableScanState::packedChildOffsets, and the served-parent
  selection on the bound chunk state (switched to unflat). Handles
  zero-length lists, capacity-limited partial lists, and cache-window
  boundaries; parents whose lists span batches are resumed seamlessly.
- Single-parent serves (without-cache, in-memory, local storage) keep
  the existing one-parent-per-batch contract.

Operator (ScanRelTable):
- Attach the descriptor for both single- and multi-parent batches; the
  batch shape is derived from the bound vector's selection size.
- Drop the speculative append/reserve machinery (superseded by direct
  offsets construction).

Consumer gating:
- Multi-parent batches change the factorization contract (bound chunk
  unflat with the served parents), so they are opt-in per consumer:
  the plan mapper enables it only for PackedFilteredCount consuming
  the scan output DIRECTLY (no FactorizedTable/hash-join between, the
  exact materialization hazard the doc warns about). Plans that fetch
  nbr node properties through the property-join pipeline keep
  single-parent batches.

PackedFilteredCount:
- Attribute counts per parent via the packed slices when present (a
  batch may span many group keys); keep the legacy single-tuple path
  when no descriptor is attached.

Tests (test/planner/cardinality_test.cpp):
- Rework the DataChunkState unit tests for the new representation and
  document the aliasing semantics in a dedicated test.
- Add a storage-level test driving RelTable::scan directly with
  packing enabled over a 3000-node/6750-edge graph (degree 3, with
  zero-child parents): asserts multi-parent batches actually occur,
  the offsets prefix-sum invariants hold, and every edge is served
  exactly once with correct parent attribution.
- Add SQL-level equivalence: the PackedFilteredCount pattern over an
  nbr property (join pipeline, single-parent batches) produces
  identical results with the packed extend on and off.

Docs: mark the deferred design as implemented in
docs/multi_parent_lifetime.md, noting the materialization boundary
constraint that keeps the property-join plan shape single-parent.